<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Manipuler le XML avec JDOM</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>xml,jdom</keywords>
        <author>Nicolas CYNOBER</author>
    </head>
    <body>
        <div class="chapter">
            <h2>Introduction</h2>
            <div class="subChapter">
                <p>JDOM est une API du langage Java développée indépendamment de Sun Microsystems. Elle permet de manipuler des donnés XML plus simplement qu'avec les API classiques. Son utilisation est pratique pour tout développer en Java et repose sur les collections XML de Sun.</p>
                <div class="quote">
                    In general we tend to prefer to avoid adding new APIs to the Java platform which replicate the functionality of existing APIs.
					However JDOM does appear to be significantly easier to use than the earlier APIs, so we believe it will be a useful addition to the platform.
                    <div class="quote_author">Sun Microsystems (Comment on the JSR-102 Approval Ballot)</div>
                </div>
                <p>
                    La documentation officielle est disponible
                    <a href="http://www.jdom.org/docs/apidocs/" target="_blank">ici</a>
                    . Au 23/01/2008 JDOM est disponible en version 1.1 et est compatible avec les versions 2 du JDK et supérieures. Vous pouvez télécharger les binaires
                    <a href="http://www.jdom.org/dist/binary/" target="_blank">ici.</a>
                    .
                </p>
                <h3>Objectif de cet article</h3>
                <p>Vous apprendrez dans cet article à manipuler des donnés XML avec le langage Java et l'API JDOM. Nous étudierons les possibilités offerte par cette API grâce à des exemples simples. Nous apprendrons ainsi à créer un simple fichier XML, à parcourir son arborescence, à modifier son contenu, etc.</p>
            </div>
        </div>
        <div class="chapter">
            <h2>Les origines de JDOM</h2>
            <div class="subChapter">
                <h3>Description de SAX</h3>
                <p>SAX est l'acronyme de Simple API for XML. Ce type de parseur utilise des événements pour piloter le traitement d'un fichier XML. Un objet (nommé handler en anglais) doit implémenter des méthodes particulières définies dans une interface de l'API pour fournir les traitements à réaliser : selon les événements, le parseur appelle ces méthodes.</p>
                <p>
                    Pour en savoir plus sur SAX, visitez
                    <a href="http://www.saxproject.org/" target="_blank">le site officiel</a>
                    .
                </p>
                <p>JDOM utilise des collections SAX pour parser les fichiers XML.</p>
                <h3>Description de DOM</h3>
                <p>DOM est l'acronyme de Document Object Model. C'est une spécification du W3C pour proposer une API qui permet de modéliser, de parcourir et de manipuler un document XML. Le principal rôle de DOM est de fournir une représentation mémoire d'un document XML sous la forme d'un arbre d'objets et d'en permettre la manipulation (parcours, recherche et mise à jour).</p>
                <p>
                    A partir de cette représentation (le modèle), DOM propose de parcourir le document mais aussi de pouvoir le modifier. Ce dernier aspect est l'un des aspect les plus intéressant de DOM. DOM est défini pour être indépendant du langage dans lequel il sera implémenté. DOM n'est qu'une spécification qui pour être utilisée doit être implémenté par un éditeur tiers.
                    <b>DOM n'est donc pas spécifique à Java</b>
                    .
                </p>
                <p>
                    Le parseur DOM pour JAVA le plus répandue est Xerces que vous pouvez trouver
                    <a href="http://xml.apache.org/">ici</a>
                    .
                </p>
                <p>JDOM utilise DOM pour manipuler les éléments d'un Model Objet de Document spécifique crée grâce à un constructeur basé sur SAX. L'on peut donc construire des documents, naviguer dans leur structure, ajouter, modifier, ou supprimer soit des éléments soit du contenu.</p>
                <h3>Pourquoi JDOM ?</h3>
                <p>
                    Une question logique que l'on peut se poser à ce stade de l'article:
                    <b>Mais qu'est-ce que JDOM nous apporte-t-il de plus ?</b>
                </p>
                <p>
                    <b>La simplicité !</b>
                    Car il est en vérité très laborieux de développer des applications complexes autour d'XML avec DOM, qui rappelons le, n'a pas été développé spécifiquement pour JAVA. Voyons maintenant toutes les possibilités que nous offre JDOM à travers des exemples simples.
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>Créer un fichier XML avec JDOM</h2>
            <div class="subChapter">
                <h3>Importer L'API JDOM</h3>
                <p>
                    Il vous faut dans un premier temps télécharger la dernière version de JDOM disponible
                    <a href="http://www.jdom.org/dist/binary/" target="_blank">ici</a>
                    . Puis importer /build/jdom.jar dans votre projet.
                </p>
                <h3>Créer une arborescence simple</h3>
                <p>La constitution d'un fichier XML en partant de zéro est des plus simple. Il suffit de construire chaque élément et de les ajouter les uns aux autres de façon logique. Un noeud est un Element.</p>
                <p>Nous commençons donc par créer une classe JDOM1 qui va se charger de créer l'arborescence suivante:</p>
                <textarea name="code" class="xml">
                    <personnes>
                        <etudiant classe="P2">
                            <nom>CynO</nom>
                            <etudiant>
                                <personnes />
                            </etudiant>
                        </etudiant>
                    </personnes>
                </textarea>
                <textarea name="code" class="java">import java.io.*;
					import org.jdom.*;
					import org.jdom.output.*;
					public class JDOM1
					{
					//Nous allons commencer notre arborescence en créant la racine XML
					//qui sera ici "personnes".
					static Element racine = new Element("personnes");
					//On crée un nouveau Document JDOM basé sur la racine que l'on vient de créer
					static org.jdom.Document document = new Document(racine);
					public static void main(String[] args)
					{
					//On crée un nouvelle Element etudiant et on l'ajoute
					//en temps qu'Element de racine
					Element etudiant = new Element("etudiant");
					racine.addContent(etudiant);
					//On crée un nouvelle Attribut classe et on l'ajoute à etudiant
					//grâce à la méthode setAttribute
					Attribute classe = new Attribute("classe","P2");
					etudiant.setAttribute(classe);
					//On crée un nouvelle Element nom, on lui assigne du text
					//et on l'ajoute en temps qu'Element de etudiant
					Element nom = new Element("nom");
					nom.setText("CynO");
					etudiant.addContent(nom);
					//Les deux appels qui suivent seront définis dans la partie 2.3.
					affiche();
					enregistre("Exercice 1.xml");
					}
					}</textarea>
                <h3>Afficher et enregistrer son fichier XML</h3>
                <p>Nous allons successivement afficher puis enregistrer notre arborescence. Nous allons utiliser une unique classe pour ces deux flux de sortie: XMLOutputter(), qui prend entre autre en argument un Format de sortie.</p>
                <p>
                    En plus de 3 formats par défaut, la classe Format contient une panoplie de méthodes pour affiner votre sérialisation. Vous pouvez trouver une description de ces méthodes
                    <a href="http://www.jdom.org/docs/apidocs/org/jdom/output/Format.html" target="_blank">ici</a>
                    .
                </p>
                <textarea name="code" class="java">//Ajouter ces deux méthodes à notre class JDOM
					static void affiche()
					{
					try
					{
					//On utilise ici un affichage classic avec getPrettyFormat()
					XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
					sortie.output(document, System.out);
					}
					catch (java.io.IOException e){}
					}
					static void enregistre(String fichier)
					{
					try
					{
					//On utilise ici un affichage classic avec getPrettyFormat()
					XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
					//Remarquez qu'il suffit simplement de créer une instance de FileOutputStream
					//avec en argument le nom du fichier pour effectuer la sérialisation.
					sortie.output(document, new FileOutputStream(fichier));
					}
					catch (java.io.IOException e){}
					}</textarea>
                <p>Après compilation voici l'affichage. Vous pouvez aller vérifier le contenu du fichier "Exercice 1.xml" dans le répertoire contenant votre class.</p>
                <textarea name="code" class="xml">
                    &lt;?xml version="1.0" encoding="UTF-8"?&gt;
                    <personnes>
                        <etudiant classe="P2">
                            <nom>CynO</nom>
                        </etudiant>
                    </personnes>
                </textarea>
                <p>Nous verons dans la troisième partie comment travailler sur un document existant, parcourir son arborescence et filtrer ses éléments.</p>
            </div>
        </div>
        <div class="chapter">
            <h2>Parcourir un fichier XML</h2>
            <div class="subChapter">
                <h3>Parser un fichier XML</h3>
                <p>Parser un fichier XML revient à transformer un fichier XML en une arborescence JDOM. Nous utiliserons pour cela le constructeur SAXBuilder, basé comme son nom l'indique sur l'API SAX.</p>
                <p>Créer tout d'abord le fichier suivant dans le répertoire contenant votre futur class JDOM2:</p>
                <p>
                    <b>Exercice 2.xml</b>
                </p>
                <textarea name="code" class="xml">
                    &lt;?xml version="1.0" encoding="UTF-8"?&gt;
                    <personnes>
                        <etudiant classe="P2">
                            <nom>CynO</nom>
                            <prenoms>
                                <prenom>Nicolas</prenom>
                                <prenom>Laurent</prenom>
                            </prenoms>
                        </etudiant>
                        <etudiant classe="P1">
                            <nom>Superwoman</nom>
                        </etudiant>
                        <etudiant classe="P1">
                            <nom>Don Corleone</nom>
                        </etudiant>
                    </personnes>
                </textarea>
                <p>Notre objectif ici est d'afficher dans un premier temps le nom de tous les élèves. Nous allons créer pour cela une nouvelle classe: JDOM2.</p>
                <textarea name="code" class="java">import java.io.*;
					import org.jdom.*;
					import org.jdom.input.*;
					import org.jdom.filter.*;
					import java.util.List;
					import java.util.Iterator;
					public class JDOM2
					{
					static org.jdom.Document document;
					static Element racine;
					public static void main(String[] args)
					{
					//L'on crée un instance du parseur SAXBuilder
					SAXBuilder sxb = new SAXBuilder();
					try
					{
					//L'on crée un nouveau document JDOM avec en argumant le fichier XML
					//Le parsing est terminé ;)
					document = sxb.build(new File("Exercice 2.xml"));
					}
					catch(Exception e){}
					//L'on initialise un nouvel element racine avec l'element racine du document.
					racine = document.getRootElement();
					//Méthode définie dans la partie 3.1. de cet article
					afficheALL();
					}
					}</textarea>
                <h3>Parcourir une arborescence</h3>
                <p>Nous utiliserons dans cette fonction deux classes apartenant à java.util:</p>
                <ul>
                    <li>
                        <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/List.html" target="_blank">java.util.List</a>
                    </li>
                    <li>
                        <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/Iterator.html" target="_blank">java.util.Iterator</a>
                    </li>
                </ul>
                <p>Nous allons créer une liste basée sur les noeuds étudiants de notre arborescence puis nous allons la parcourir grâce à un iterator.</p>
                <textarea name="code" class="java">//Ajouter cette méthodes à la classe JDOM2
					static void afficheALL()
					{
					//L'on crée une list contenant tous les noeud "etudiant" de l'Element racine
					List listEtudiants = racine.getChildren("etudiant");
					//L'on crée un iterator sur notre liste (sorte d'index)
					Iterator i = listEtudiants.iterator();
					while(i.hasNext())
					{
					//L'on recrée l'Element courant à chaque tour de boucle afin de
					//pouvoir utiliser les méthodes propres aux Element comme:
					//selectionner un noeud fils, modifier du text, etc...
					Element courant = (Element)i.next();
					//On affiche le nom de l'element courant
					System.out.println(courant.getChild("nom").getText());
					}
					}</textarea>
                <p>A la compilation vous devriez voir s'afficher CynO, Superwoman et Don Corleone.</p>
                <h3>Filtrer les éléments</h3>
                <p>Notre nouvel objectif est d'afficher la classe des étudiants dont le prénom est Laurent et le nom est CynO.</p>
                <p>Les seuls filtres que nous ayons fait pour le moment étaient directement implantés dans les méthodes que nous utilisions.</p>
                <textarea name="code" class="java">List listEtudiants = racine.getChildren("etudiant")</textarea>
                <p>nous a permis de filtrer les sous Elements de racine selon leur nom.</p>
                <p>Vous aurez remarqué que de toute façon nous n'avions que des etudiants, le problème ne se posait donc pas ;)</p>
                <p>Les filtres permettent des sélections d'éléments selon plusieurs critères. Nous allons donc créer un filtre qui permettra de ne prendre en compte que les Elements qui possèdent:</p>
                <ul>
                    <li>Un sous élément nom qui doit avoir pour valeur "CynO".</li>
                    <li>Un sous élément prenoms et ce dernier doit au moins posséder un sous élément prenom dont la valeur est "Laurent".</li>
                </ul>
                <p>Une fois le filtre créé nous pourrons créer une liste répondant à ces critères.</p>
                <textarea name="code" class="java">//Ajouter cette Méthode à la classe JDOM2
					//Remplacer la ligne afficheALL(); par afficheFiltre();
					static void afficheFiltre()
					{
					//L'on crée un nouveau filtre
					Filter filtre = new Filter()
					{
					//L'on définie les propriétés du filtre à l'aide
					//de la méthode matches
					public boolean matches(Object ob)
					{
					//1er vérification: On vérifie que les objets
					//qui seront filtrés sont bien des Elements
					if(!(ob instanceof Element)){return false;}
					//On crée alors un Element sur lequel on va faire les
					//vérifications suivantes.
					Element element = (Element)ob;
					//On crée deux variables qui vont nous permettre de vérifier
					//les conditions de nom et de prenom
					int verifNom= 0;
					int verifPrenom= 0;
					//2eme vérification: On vérifie que le nom est bien "CynO"
					if(element.getChild("nom").getTextTrim().equals("CynO"))
					{
					verifNom = 1;
					}
					//3eme vérification: On vérifie que CynO possède un prenom "Laurent"
					//On commence par vérifier que la personne possède un prenom,
					//en effet notre fichier XML possède des étudiants sans prénom !
					Element prenoms = element.getChild("prenoms");
					if(prenoms==null){return false;}
					//On constitue une list avec tous les prenom
					List listprenom = prenoms.getChildren("prenom");
					//On effectue la vérification en parcourant notre list de prenom
					//(voir: 3.1. Parcourir une arborescence)
					Iterator i = listprenom.iterator();
					while(i.hasNext())
					{
					Element courant = (Element)i.next();
					if(courant.getText().equals("Laurent"))
					{
					verifPrenom = 1;
					}
					}
					//Si nos conditions sont remplis on retourne true, au sinon false
					if(verifNom == 1 &amp;&amp; verifPrenom == 1)
					{
					return true;
					}
					return false;
					}
					};//Fin du filtre
					//getContent va utiliser notre filtre pour créer une list d'étudiant répondant
					//à nos critères.
					List resultat = racine.getContent(filtre);
					//On affiche enfin la classe de tous les éléments de notre list
					Iterator i = resultat.iterator();
					while(i.hasNext())
					{
					Element courant = (Element)i.next();
					System.out.println(courant.getAttributeValue("classe"));
					}
					}</textarea>
                <p>A la compilation vous devriez voir s'afficher P2 à votre écran.</p>
                <p>La puissance de cet outil réside dans sa capacité à être utilisé à tout moment par n'importe quel Element de votre arborescence.</p>
                <p>
                    Dans notre exemple nous nous sommes servi de notre filtre JDOM comme d'un moteur de recherche. Et il est tout à fait envisageable de créer des filtres dynamiques selon vos besoins. Pour en savoir plus sur la classe Filter je vous invite à vous rendre
                    <a href="http://www.jdom.org/docs/apidocs/org/jdom/filter/package-summary.html" target="_blank">ici</a>
                    .
                </p>
            </div>
        </div>
        <div class="chapter">
            <h2>Modifier une arborescence JDOM</h2>
            <div class="subChapter">
                <h3>Modifier des Elements</h3>
                <p>Nous avons jusqu'à présent utilisé que des méthodes de sélection sur nos Elements. Mais il existe un grand nombre de méthodes nous permettant de remplacer et d'ajouter différents types d'objets dans notre arborescence.</p>
                <p>Je vous propose donc de faire une liste de toutes les méthodes de modification les plus utiles :</p>
                <table width="100%" border="1">
                    <tbody>
                        <tr>
                            <td width="12%">
                                <strong>Nom</strong>
                            </td>
                            <td width="26%">Arguments des surcharges</td>
                            <td width="62%">Description</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>addContent</strong>
                            </td>
                            <td>
                                <em>Collection</em>
                                ,
                                <em>String</em>
                                ou
                                <em>Content</em>
                                , c'est à
								dire un
                                <em>Element</em>
                                ou quoi que se soit qui peut être contenu
								par un noeud.
                            </td>
                            <td>Ajoute le contenu de l'argument à la fin du contenu d'un Element.
								On peut spécifier un index pour l'inserer à la position voulu.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>clone</strong>
                            </td>
                            <td> </td>
                            <td>Retourne un clone parfait de l'Element.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>cloneContent</strong>
                            </td>
                            <td> </td>
                            <td>Comme son nom l'indique on ne copie que le contenu.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>removeAttribute</strong>
                            </td>
                            <td>
                                <em>Attribut</em>
                                ou nom de l'attribut (
                                <em>String</em>
                                )
                            </td>
                            <td>Supprime un attribut d'un Element</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>removeChild</strong>
                            </td>
                            <td>
                                nom du noeud enfant (
                                <em>String</em>
                                )
                            </td>
                            <td>Supprime le premier enfant portant ce nom.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>removeChildren</strong>
                            </td>
                            <td>
                                nom des noeuds enfants (
                                <em>String</em>
                                )
                            </td>
                            <td>Supprime tous les enfants ayant ce nom.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>removeContent</strong>
                            </td>
                            <td>
                                <em>Content</em>
                                ,
                                <em>Index</em>
                                ou
                                <em>Filtre</em>
                            </td>
                            <td>Supprime l'intégralité d'un noeud donné en argument
								ou par sa position. removeContent accept aussi les filtres, tout comme getContent
								vu précédement.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>setAttributes</strong>
                            </td>
                            <td>
                                <em>Attribut</em>
                                ou nom de l'attribut et sa valeur (
                                <em>String, String</em>
                                )
                            </td>
                            <td>Cette méthode permet à la fois de créer un attribut
								et d'en modifier sa valeur.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>setContent</strong>
                            </td>
                            <td>
                                <em>Content</em>
                            </td>
                            <td>Remplace le contenu d'un Element. On peut spécifier un index si
								l'on ne veut pas tout remplacer.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>setName</strong>
                            </td>
                            <td>
                                Nouveau nom de l'Element (
                                <em>String</em>
                                )
                            </td>
                            <td>Change le nom de l'Element.</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>setText</strong>
                            </td>
                            <td>
                                Nouveau Text à inserer (
                                <em>String</em>
                                )
                            </td>
                            <td>Change le text contenu par l'Element. &lt;element&gt;TEXT&lt;/element&gt;</td>
                        </tr>
                        <tr valign="top">
                            <td>
                                <strong>toString</strong>
                            </td>
                            <td> </td>
                            <td>Retourne une représentation de l'Element sous forme de chaine.</td>
                        </tr>
                    </tbody>
                </table>
                <p>
                    Pour plus de détail je vous convie à vous rendre
                    <a href="http://www.jdom.org/docs/apidocs/org/jdom/Element.html" target="_blank">ici</a>
                    .
                </p>
                <p>Maintenant voyons un petit exemple de modification d'arborescence. Il vous paraîtra simpliste à coté de ce que nous avons fait jusqu'a présent mais c'est justement le but:</p>
                <p>Je tiens à vous montrer que JDOM c'est la simplicité avant tout ! Nous allons modifier le contenu de notre fichier Exemple 2.xml (de la partie 3.1) en supprimant tous les Elements prenoms de notre arborescence.</p>
                <textarea name="code" class="java">//Créer une nouvelle class JDOM3
					import java.io.*;
					import org.jdom.*;
					import org.jdom.input.*;
					import org.jdom.output.*;
					import java.util.List;
					import java.util.Iterator;
					public class JDom
					{
					static org.jdom.Document document;
					static Element racine;
					public static void main(String[] args)
					{
					try
					{
					lireFichier("Exercice 2.xml");
					supprElement("prenoms");
					enregistreFichier("Exercice 2.xml");
					}
					catch(Exception e){}
					}
					//On parse le fichier et on initialise la racine de
					//notre arborescence
					static void lireFichier(String fichier) throws Exception
					{
					SAXBuilder sxb = new SAXBuilder();
					document = sxb.build(new File(fichier));
					racine = document.getRootElement();
					}
					//L'on fait des modifications sur un Element
					static void supprElement(String element)
					{
					//Dans un premier temps on list tous les étudiants
					List listEtudiant = racine.getChildren("etudiant");
					Iterator i = listEtudiant.iterator();
					//On parcours la liste grâce à un iterator
					while(i.hasNext())
					{
					Element courant = (Element)i.next();
					//Si l'etudiant possède l'Element en question on applique
					//les modifications.
					if(courant.getChild(element)!=null)
					{
					//On supprime l'Element en question
					courant.removeChild(element);
					//On renomme l'Element père sachant qu'une balise XML n'accept
					//ni les espaces ni les caractères spéciaux
					//"etudiant modifié" devient "etudiant_modifie"
					courant.setName("etudiant_modifie");
					}
					}
					}
					//On enregsitre notre nouvelle arborescence dans le fichier
					//d'origine dans un format classique.
					static void enregistreFichier(String fichier) throws Exception
					{
					XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
					sortie.output(document, new FileOutputStream(fichier));
					}
					}</textarea>
                <p>Voici le contenu du fichier "Exemple 2.xml" après compilation.</p>
                <textarea name="code" class="xml">
                    &lt;?xml version="1.0" encoding="UTF-8"?&gt;
                    <personnes>
                        <etudiant_modifie classe="P2">
                            <nom>CynO</nom>
                        </etudiant_modifie>
                        <etudiant classe="P1">
                            <nom>Superwoman</nom>
                        </etudiant>
                        <etudiant classe="P1">
                            <nom>Don Corleone</nom>
                        </etudiant>
                    </personnes>
                </textarea>
                <h3>Transformer JDOM</h3>
                <h4>Passer de DOM à JDOM et l'inverse</h4>
                <p>Il vous arrivera parfois de devoir travailler sur un document DOM.</p>
                <p>Nous allons voir comment transformer un document DOM en un document JDOM et vis versa. Voici une petite fonction qui reçoit en argument un document DOM et qui retourne un document JDOM.</p>
                <textarea name="code" class="java">//Pour être compilé cette fonction à besoin de l'importation suivante
					//qui contient la classe DOMBuilder
					import org.jdom.input.*;
					org.jdom.Document DOMtoJDOM(org.w3c.dom.Document documentDOM) throws Exception
					{
					//On utilise la classe DOMBuilder pour cette transformation
					DOMBuilder builder = new DOMBuilder();
					org.jdom.Document documentJDOM = builder.build(documentDOM);
					return documentJDOM;
					}</textarea>
                <p>Et maintenant voici la fonction inverse qui reçoit en argument un document JDOM et qui retourne un document DOM.</p>
                <p>Vous remarquerez la similitude avec la fonction précédente.</p>
                <textarea name="code" class="java">//Pour être compilé cette fonction à besoin de l'importation suivante
					//qui contient la classe DOMOutputter
					import org.jdom.output.*;
					org.w3c.dom.Document DOMtoJDOM(org.jdom.Document documentJDOM) throws Exception
					{
					//On utilise la classe DOMOutputter pour cette transformation
					DOMOutputter domOutputter = new DOMOutputter();
					org.w3c.dom.Document documentDOM = domOutputter.output(documentJDOM);
					return documentDOM;
					}</textarea>
                <h4>JDOM et XSLT</h4>
                <p>Grâce à l'API JAXP et TraX il est très facile de faire des transformation XSLT sur un document JDOM. Dans l'exemple suivant nous allons créer une fonction qui prend en entrée un document JDOM et le nom d'un fichier XSL et qui crée en sortie un fichier XML transformé.</p>
                <textarea name="code" class="java">//Pour être compilé cette fonction à besoin des importations suivantes
					import java.io.*;
					//JDOM
					import org.jdom.transform.*;
					import org.jdom.output.*;
					//TrAX
					import javax.xml.transform.*;
					import javax.xml.transform.stream.StreamSource;
					void outputXSLT(org.jdom.Document documentJDOMEntree,String fichierXSL)
					{
					//Document JDOMResult, résultat de la transformation TraX
					JDOMResult documentJDOMSortie = null;
					//Document JDOM après transformation
					org.jdom.Document resultat = null;
					try
					{
					//On définit un transformer avec la source XSL
					//qui va permettre la transformation
					TransformerFactory factory = TransformerFactory.newInstance();
					Transformer transformer = factory.newTransformer(new StreamSource(fichierXSL));
					//On transforme le document JDOMEntree grâce à notre transformer.
					//La méthoded transform() prend en argument le document d'entree associé au transformer
					//et un document JDOMResult, résultat de la transformation TraX
					transformer.transform(new org.jdom.transform.JDOMSource(documentJDOMEntree), documentJDOMSortie);
					//Pour récupérer le document JDOM issu de cette transformation
					//il faut utiliser la méthode getDocument()
					resultat = documentJDOMSortie.getDocument();
					//On crée un fichier xml corespondant au résultat
					XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
					outputter.output(resultat, new FileOutputStream("resultat.xml"));
					}
					catch(Exception e){}
					}</textarea>
                <h3>Conclusion</h3>
                <p>Vous vous êtes maintenant rendu compte de l'utilité de JDOM dans le traitement de données XML avec Java.</p>
                <p>Cependant cette API est encore toute jeune et en voie d'amélioration.</p>
                <p>Pour en apprendre plus sur JDOM et rester informé je vous conseil les sites suivants:</p>
                <ul>
                    <li>
                        <a href="http://www.jdom.org" target="_blank">http://www.jdom.org</a>
                    </li>
                    <li>
                        <a href="http://java.sun.com" target="_blank">http://java.sun.com</a>
                    </li>
                    <li>
                        <a href="http://www.cafeconleche.org/" target="_blank">http://www.cafeconleche.org</a>
                    </li>
                </ul>
                <p>
                    Je tiens à remercier également
                    <a href="http://www.developpez.net/forums/viewforum.php?f=11" target="_blank">forums de developpez.com</a>
                    pour leur aide.
                </p>
                <p>
                    Pour toutes questions
                    <a href="mailto:nicolas.cynober@supinfo.com">nicolas.cynober@supinfo.com</a>
                </p>
            </div>
        </div>
    </body>
</html>

